home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 22 / AACD 22.iso / AACD / Sound / Subspace68k / src / Waveshapes_OPT.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-05-04  |  18.1 KB  |  499 lines
  1.  
  2. #include <exec/types.h>
  3. #include <math.h>
  4.  
  5. #ifdef __SASC
  6.         #define M_PI PI
  7. #else
  8.     #define M_PI 3.1415927
  9. #endif
  10.  
  11. float rnd(float max);
  12.  
  13. float wa0[2], wa1[2], wa2[2], wa3[2], wa4[2], wa5[2], wa6[2], wa7[2], wa8[2];
  14. float wb0[2], wb1[2], wb2[2], wb3[2], wb4[2], wb5[2], wb6[2], wb7[2], wb8[2];
  15.  
  16. extern ULONG TimeWave;
  17. extern WORD      *PluginSamples;
  18.  
  19.  
  20. void InitWave(UBYTE WaveNum, ULONG BufNum) {
  21.         float a0,a1,a2,a3,a4;
  22.         a0=a1=a2=a3=a4=0.0;
  23.         switch(WaveNum) {
  24.                 /****************************************/
  25.                 case 0:
  26.                 break;
  27.                 /****************************************/
  28.                 case 1:
  29.                 break;
  30.                 /****************************************/
  31.                 case 2:
  32.                         a0 = 0.1 + rnd(0.2);
  33.                 break;
  34.                 /****************************************/
  35.                 /** Radar Sweep                        **/
  36.                 case 3:
  37.                         a0 = 0.7 + rnd(1.1);
  38.                 break;
  39.                 /****************************************/
  40.                 /** Flower Power                       **/
  41.                 case 4:
  42.                         a0 = 2.0 + (float)((ULONG)(0.99 * rnd(4.0)));
  43.                         a1 = M_PI * (float)(2 - (ULONG)a0 % 2);
  44.                         a2 = 0.2  + rnd(0.2);
  45.                         a3 = 0.65 + rnd(0.22);
  46.                 break;
  47.                 /****************************************/
  48.                 /** Spinit                             **/
  49.                 case 5:
  50.                         a0 = 0.25 + rnd(0.4);
  51.                 break;
  52.                 /****************************************/
  53.                 /** Sine Waves                         **/
  54.                 case 6:
  55.                 break;
  56.                 /****************************************/
  57.                 /** Five                               **/
  58.                 case 7:
  59.                         a0 = cos(.3 + rnd(.6)) * 0.5;
  60.                         a1 = sin(.5 + rnd(.4)) * 0.5;
  61.                         a2 = cos(.1 + rnd(.8)) * 0.5;
  62.                         a3 = sin(.2 + rnd(.7)) * 0.5;
  63.                         a4 = cos(.6 + rnd(.3)) * 0.5;
  64.                 break;
  65.                 /****************************************/
  66.                 /** Rotating Arcs                      **/
  67.               case 8:
  68.                       a0 = 0.5 + rnd(0.2);
  69.                         a1 = rnd(1.3) + 1.4;
  70.  
  71.                 break;
  72.  
  73.  
  74.                 /****************************************/
  75.                 /** Horizontal Sweep                   **/
  76.                 case 9:
  77.                 break;
  78.                 /****************************************/
  79.                 /** NTPU Squared                       **/
  80.                 case 10:
  81.                         a0 = 0.3 + rnd(0.4);
  82.                         a1 = 0.4 * a0;
  83.                 break;
  84.  
  85.                 /****************************************/
  86.                 /** Particle Pulse                     **/
  87.                 case 11:
  88.                         a0 = rnd(3)+1;
  89.                 break;
  90.                 /****************************************/
  91.         }
  92.         wa0[BufNum] = a0;
  93.         wa1[BufNum] = a1;
  94.         wa2[BufNum] = a2;
  95.         wa3[BufNum] = a3;
  96.         wa4[BufNum] = a4;
  97. }
  98.  
  99. void CalcWave(UBYTE WaveNum, ULONG BufNum) {
  100.         float tf;
  101.         float a0,a1,a2,a3,a4;
  102.         float b0,b1,b2,b3,b4,b5,b6,b7,b8;
  103.  
  104.         a0 = wa0[BufNum];
  105.         a1 = wa1[BufNum];
  106.         a2 = wa2[BufNum];
  107.         a3 = wa3[BufNum];
  108.         a4 = wa4[BufNum];
  109.         b0 = 0;
  110.         b1 = 0;
  111.         b2 = 0;
  112.         b3 = 0;
  113.         b4 = 0;
  114.         b5 = 0;
  115.         b6 = 0;
  116.         b7 = 0;
  117.         b8 = 0;
  118.         tf=((float)TimeWave) / 10.0;
  119.         switch(WaveNum) {
  120.                 /****************************************/
  121.                 case 0:
  122.                    break;
  123.                 /****************************************/
  124.                 case 1:
  125.                         b0 = tf * 0.0003;
  126.                 break;
  127.                 /****************************************/
  128.                 case 2:
  129.                         b0 = cos(tf * 0.2);
  130.                         b1 = sin(tf * 0.2);
  131.                 break;
  132.                 /****************************************/
  133.                 /** Radar Sweep                        **/
  134.                 case 3:
  135.                         b0 = cos(tf * a0);
  136.                         b1 = sin(tf * a0);
  137.                 break;
  138.                 /****************************************/
  139.                 /** Flower Power                       **/
  140.                 case 4:
  141.                         b0 = tf;
  142.                 break;
  143.                 /****************************************/
  144.                 /** Spinit                             **/
  145.                 case 5:
  146.                         b0 = cos(a0 * tf);
  147.                         b1 = sin(a0 * tf);
  148.                 break;
  149.                 /****************************************/
  150.                 /** Sine Waves                         **/
  151.                 case 6:
  152.                 break;
  153.                 /****************************************/
  154.                 /** Five                               **/
  155.                 case 7:
  156.                         b0 = -1.0 * tf;
  157.                         b1 = .3 * tf;
  158.                         b2 = -.8 * tf + 1.23213;
  159.                         b3 = .3 * tf;
  160.                         b4 = -1.3 * tf;
  161.                         b5 = -1.1 * tf + 4.45245;
  162.                         b6 = -.63 * tf + 2.13213;
  163.                         b7 = .7 * cos(b1);
  164.                         b8 = .7 * sin(b1);
  165.                 break;
  166.                 /****************************************/
  167.                 /** Rotating Arcs                      **/
  168.  
  169.                 case 8:
  170.  
  171.                         b0 = 0.3 * tf;
  172.  
  173.                 break;
  174.  
  175.                 /****************************************/
  176.                 /** Horizontal Sweep                   **/
  177.                 case 9:
  178.                         b0 = sin(0.5*tf);
  179.                 break;
  180.                 /****************************************/
  181.                 /** NTPU Squared                       **/
  182.  
  183.                 case 10:
  184.                         b0 = cos(tf * 0.18);
  185.                         b1 = sin(tf * 0.18);
  186.                 break;
  187.  
  188.                 /****************************************/
  189.                 /** Particle Pulse                     **/
  190.                 case 11:
  191.                         b0 = tf * 0.0003;
  192.                 break;
  193.                 /****************************************/
  194.         }
  195.         wb0[BufNum] = b0;
  196.         wb1[BufNum] = b1;
  197.         wb2[BufNum] = b2;
  198.         wb3[BufNum] = b3;
  199.         wb4[BufNum] = b4;
  200.         wb5[BufNum] = b5;
  201.         wb6[BufNum] = b6;
  202.         wb7[BufNum] = b7;
  203.         wb8[BufNum] = b8;
  204. }
  205.  
  206. void DrawWave(LONG *WaveX, LONG *WaveY, ULONG Width, ULONG Height, UBYTE WaveNum, ULONG BufNum) {
  207.         LONG i,xs,ys,xd,yd;
  208.         LONG k;
  209.         LONG minx,maxx,miny,maxy;
  210.  
  211.         float scales,scaled,greater;
  212.         float xsf,ysf;
  213.         float xdf0,ydf0,xdf1,ydf1,xdf2,ydf2;
  214.         float wf,hf,tf;
  215.  
  216.         float a0, a1, a2, a3, a4;
  217.         float b0, b1, b2, b3, b4, b5, b6, b7, b8;
  218.         float c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10;
  219.       float cns1,cns2,cns3,cns4,cns5,cns6,cns7,cns8,cns9;
  220.  
  221.         a0 = wa0[BufNum];
  222.         a1 = wa1[BufNum];
  223.         a2 = wa2[BufNum];
  224.         a3 = wa3[BufNum];
  225.         a4 = wa4[BufNum];
  226.  
  227.         b0 = wb0[BufNum];
  228.         b1 = wb1[BufNum];
  229.         b2 = wb2[BufNum];
  230.         b3 = wb3[BufNum];
  231.         b4 = wb4[BufNum];
  232.         b5 = wb5[BufNum];
  233.         b6 = wb6[BufNum];
  234.         b7 = wb7[BufNum];
  235.         b8 = wb8[BufNum];
  236.  
  237.         wf=(float)Width;
  238.         hf=(float)Height;
  239.         tf=((float)TimeWave) / 10.0;
  240.  
  241. cns1 = Width/2;
  242. cns2 = Height/2;
  243.  
  244.         minx = -(cns1)  + 1;
  245.         maxx =  (cns1)  - 1;
  246.         miny = -(cns2) + 1;
  247.         maxy =  (cns2) - 1;
  248.  
  249.         greater=1.0;
  250.         if(wf > greater) greater = wf;
  251.         if(hf > greater) greater = hf;
  252.  
  253.         scales = 1.0 / greater;
  254.         scaled = 1.0 / (greater/2.0);
  255.  
  256.         k=0;
  257.         for(xs=0; xs<(Width); xs++) {
  258.                 ys = (PluginSamples[k++] >> 10) + (PluginSamples[k++] >> 10);
  259.  
  260.                 xsf = ((float)xs) * scales;
  261.                 ysf = ((float)ys) / 256.0;
  262.  
  263.                 switch(WaveNum) {
  264.                         /****************************************/
  265.                         case 0:
  266.                                 xdf0 = 2*xsf-1;
  267.                                 ydf0 = ysf * 0.75;
  268.                                 xdf1 = xdf0;
  269.                                 ydf1 = ydf0;
  270.                         break;
  271.                         /****************************************/
  272.                         case 1:
  273.                                 c0 = ysf * 0.2 + .2;
  274.                                 c1 = xsf * 6.28318530 + b0;
  275.                                 xdf0 = c0 * cos(c1);
  276.                                 ydf0 = c0 * sin(c1);
  277.                                 xdf1 = xdf0;
  278.                                 ydf1 = ydf0;
  279.                         break;
  280.                         /****************************************/
  281.                         case 2:
  282.                 cns3 = b0*c1;
  283.                 cns4 = b1*c0;
  284.                 cns5 = b0*c0;
  285.                 cns6 = b1*c1;
  286.                                 c0 = ysf * 0.25 + .2;
  287.                                 c1 = 2.1 * (xsf-0.5);
  288.                                 xdf0 =  cns3 + cns4;
  289.                                 ydf0 = -cns5 + cns6;
  290.                                 xdf1 =  cns3 - cns4;
  291.                                 ydf1 =  cns5 + cns6;
  292.                         break;
  293.                         /****************************************/
  294.                         /** Radar Sweep                        **/
  295.                         case 3:
  296.                                 c0   = ysf * 0.4 * xsf;
  297.                                 xdf0 = -b0 * xsf - b1 * c0;
  298.                                 ydf0 =  b0 * c0  - b1 * xsf;
  299.                                 xdf1 = xdf0;
  300.                                 ydf1 = ydf0;
  301.                         break;
  302.                         /****************************************/
  303.                         /** Flower Power                       **/
  304.                         case 4:
  305.                                 c0   = a1 * xsf;
  306.                                 c1   = a3 * cos(a0*c0) + 0.18 * ysf;
  307.                                 xdf0 = c1 * cos(c0+a2*b0);
  308.                                 ydf0 = c1 * sin(c0+a2*b0);
  309.                                 xdf1 = xdf0;
  310.                                 ydf1 = ydf0;
  311.                         break;
  312.                         /****************************************/
  313.                         /** Spinit                             **/
  314.                         case 5:
  315.                                 c0   = 2 * xsf - 1;
  316.                                 c1   = ysf * 0.6 + c0;
  317.                 cns3 = b0*c1;
  318.                 cns4 = b1*c0;
  319.                 cns5 = b0*c0;
  320.                 cns6 = b1*c1;
  321.                                 xdf0 = - cns5 - cns6;
  322.                                 ydf0 =   cns3 - cns4;
  323.                                 xdf1 = - cns5 + cns6;
  324.                                 ydf1 =   cns3 + cns4;
  325.                         break;
  326.                        /****************************************/
  327.                         /** Sine Waves                         **/
  328.  
  329.                         case 6:
  330.                                 c0   = - sin(6.2831853 * xsf);
  331.                                 c1   = 0.4 * ysf;
  332.                                 xdf0 = 2.0 * xsf - 1 - c0 * c1;
  333.                                 ydf0 = 0.7 * cos( 6.2831853 * xsf ) + sqrt( 1 - c0*c0 ) * c1;
  334.                                 xdf1 = xdf0;
  335.                                 ydf1 = -ydf0;
  336.                         break;
  337.                         /****************************************/
  338.                         /** Five                               **/
  339.                         case 7:
  340.                 cns9 = xsf - .1;
  341.  
  342.  
  343.                                 c0   = b7 * cns9 + a0;
  344.                                 c1   = b8 * cns9 + a0;
  345.                                 c2   = .7 * cns9 * sin( b3 ) + a1;
  346.                                 c3   = .7 * cns9 * cos( b3 ) + a1;
  347.                                 c4   = b7 * cns9 + a2;
  348.                                 c5   = b8 * cns9 + a2;
  349.                                 c6   = b7 * cns9 + a3;
  350.                                 c7   = b8 * cns9 + a3;
  351.                                 c8   = b7 * cns9 + a4;
  352.                                 c9   = b8 * cns9 + a4;
  353.                                 c10  = .7 * ysf;
  354.  
  355.                                 switch(xs%5) {
  356.                                         case 0:
  357.                     cns7 = c1 * sin(b0);
  358.                     cns8 = c0 * cos(b0);
  359.  
  360.                                                 xdf0 = cns8 - cns7;
  361.                                                 ydf0 = cns7 + cns8 * c10;
  362.                                         break;
  363.                                         case 1:
  364.                     cns7 = c0 * sin(b2);
  365.                     cns8 = c1 * cos(b2);
  366.  
  367.                                                 xdf0 = -(cns7 - cns8);
  368.                                                 ydf0 = -(cns8 + cns7 * c10);
  369.                                         break;
  370.                                         case 2:
  371.                     cns7 = c4 * sin(b4);
  372.                     cns8 = c5 * cos(b4);
  373.  
  374.                                                 xdf0 = -(cns7 - cns8);
  375.                                                 ydf0 = -(cns8 + cns7 * c10);
  376.                                         break;
  377.                                         case 3:
  378.                     cns7 = c7 * sin(b5);
  379.                     cns8 = c6 * cos(b5);
  380.  
  381.                                                 xdf0 = cns8 - cns7;
  382.                                                 ydf0 = cns7 + cns8 * c10;
  383.                                         break;
  384.                                         case 4:
  385.                     cns7 = c9 * sin(b6);
  386.                     cns8 = c8 * cos(b6);
  387.  
  388.                                                 xdf0 = -cns8 - cns7;
  389.                                                 ydf0 = -cns7 + cns8 * c10;
  390.                                         break;
  391.                                 }
  392.                                 xdf1 = xdf0;
  393.                                 ydf1 = ydf0;
  394.                         break;
  395.                         /****************************************/
  396.                         /** Rotating Arcs                      **/
  397.                         case 8:
  398.  
  399.                                 c0   = a0 + .025 * ysf;
  400.                                 c1   = b0 + a1 * xsf;
  401.  
  402.                                 xdf0 = c0 * cos(c1);
  403.                                 ydf0 = c0 * sin(c1);
  404.                                 xdf1 = c0 * cos(c1 + 3.14159);
  405.                                 ydf1 = c0 * sin(c1 + 3.14159);
  406.                         break;
  407.  
  408.                         /****************************************/
  409.                         /** Horizontal Sweep                   **/
  410.                         case 9:
  411.                                 c0   = 2 * (xsf - 0.5);
  412.                                 c1   = 0.7 * b0 + ysf * 0.25;
  413.  
  414.                                 xdf0 =  c1;
  415.                                 ydf0 =  c0;
  416.                                 xdf1 = -c1;
  417.                                 ydf1 =  c0;
  418.                         break;
  419.                         /****************************************/
  420.                         /** NTPU Squared                       **/
  421.                         case 10:
  422.  
  423.                                 c0   = a1 * ysf + a0;
  424.                                 c1   = 2.0 * a0 * (xsf - 0.5);
  425.                 cns3 = b0*c1;
  426.                 cns4 = b1*c0;
  427.                 cns5 = b0*c0;
  428.                 cns6 = b1*c1;
  429.  
  430.  
  431.                                 switch(xs%2) {
  432.                                         case 0:
  433.                                                 xdf0 =   cns3 + cns4;
  434.                                                 ydf0 = - cns5 + cns6;
  435.                                                 xdf1 =   cns3 - cns4;
  436.                                                 ydf1 =   cns5 + cns6;
  437.                                         break;
  438.                                         case 1:
  439.                                                 xdf0 = - cns3 - cns4;
  440.                                                 ydf0 = - cns5 + cns6;
  441.                                                 xdf1 = - cns3 + cns4;
  442.                                                 ydf1 =   cns5 + cns6;
  443.                                         break;
  444.                                 }
  445.                         break;
  446.  
  447.                         /****************************************/
  448.                         /** NTPU Squared                       **/
  449.                         case 11:
  450.                                 c0   = fabs(ysf) * 0.85 + 0.05;
  451.                                 c1   = xsf * 43.766877 - b0;
  452.  
  453.                 cns7 = c0 * sin(c1);
  454.                 cns8 = c0 * cos(c1);
  455.  
  456.                                 switch(xs%2) {
  457.                                         case 0:
  458.  
  459.                                                 xdf0 = cns8;
  460.                                                 ydf0 = cns7;
  461.                                                 xdf1 = cns8+scaled;
  462.                                                 ydf1 = cns7;
  463.                                         break;
  464.  
  465.                                         case 1:
  466.                                                 xdf0 = cns8;
  467.                                                 ydf0 = cns7+scaled;
  468.                                                 xdf1 = cns8;
  469.                                                 ydf1 = cns7+scaled;
  470.                                         break;
  471.                                 }
  472.                         break;
  473.                         /****************************************/
  474.                 }
  475.  
  476.                 xd = xdf0/scaled;
  477.                 yd = ydf0/scaled;
  478.                 /**
  479.                 if(xd < minx) xd = minx;
  480.                 if(xd > maxx) xd = maxx;
  481.                 if(yd < miny) yd = miny;
  482.                 if(yd > maxy) yd = maxy;
  483.                 **/
  484.                 WaveX[xs] = xd;
  485.                 WaveY[xs] = yd;
  486.  
  487.                 xd = xdf1/scaled;
  488.                 yd = ydf1/scaled;
  489.                 /**
  490.                 if(xd < minx) xd = minx;
  491.                 if(xd > maxx) xd = maxx;
  492.                 if(yd < miny) yd = miny;
  493.                 if(yd > maxy) yd = maxy;
  494.                 **/
  495.                 WaveX[xs+Width] = xd;
  496.                 WaveY[xs+Width] = yd;
  497.         }
  498. }
  499.